home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / sf1.c < prev    next >
C/C++ Source or Header  |  2000-04-04  |  6KB  |  268 lines
  1. #include "driver.h"
  2. #include "vidhrdw/generic.h"
  3.  
  4. unsigned char *sf1_objectram;
  5.  
  6. int sf1_active = 0;
  7.  
  8. static struct tilemap *bgb_tilemap, *bgm_tilemap, *char_tilemap;
  9.  
  10.  
  11. /***************************************************************************
  12.  
  13.   Callbacks for the TileMap code
  14.  
  15. ***************************************************************************/
  16.  
  17. static void get_bgb_tile_info(int tile_index)
  18. {
  19.     unsigned char *base = memory_region(REGION_GFX5) + 2*tile_index;
  20.     int attr = base[0x10000];
  21.     int color = base[0];
  22.     int code = (base[0x10000+1]<<8) | base[1];
  23.     SET_TILE_INFO (0, code, color);
  24.     tile_info.flags = TILE_FLIPYX(attr & 3);
  25. }
  26.  
  27. static void get_bgm_tile_info(int tile_index)
  28. {
  29.     unsigned char *base = memory_region(REGION_GFX5) + 0x20000 + 2*tile_index;
  30.     int attr = base[0x10000];
  31.     int color = base[0];
  32.     int code = (base[0x10000+1]<<8) | base[1];
  33.     SET_TILE_INFO (1, code, color);
  34.     tile_info.flags = TILE_FLIPYX(attr & 3);
  35. }
  36.  
  37. static void get_char_tile_info(int tile_index)
  38. {
  39.     int code = READ_WORD(&videoram[2*tile_index]);
  40.     SET_TILE_INFO (3, code & 0x3ff, code>>12);
  41.     tile_info.flags = TILE_FLIPYX((code & 0xc00)>>10);
  42. }
  43.  
  44.  
  45.  
  46. /***************************************************************************
  47.  
  48.   Start the video hardware emulation.
  49.  
  50. ***************************************************************************/
  51.  
  52. int sf1_vh_start(void)
  53. {
  54.     int i;
  55.  
  56.     bgb_tilemap =  tilemap_create(get_bgb_tile_info, tilemap_scan_cols,TILEMAP_OPAQUE,     16,16,2048,16);
  57.     bgm_tilemap =  tilemap_create(get_bgm_tile_info, tilemap_scan_cols,TILEMAP_TRANSPARENT,16,16,2048,16);
  58.     char_tilemap = tilemap_create(get_char_tile_info,tilemap_scan_rows,TILEMAP_TRANSPARENT, 8, 8,  64,32);
  59.  
  60.     if (!bgb_tilemap || !bgm_tilemap || !char_tilemap)
  61.         return 1;
  62.  
  63.     bgm_tilemap->transparent_pen = 15;
  64.     char_tilemap->transparent_pen = 3;
  65.  
  66.     for(i = 832; i<1024; i++)
  67.         palette_used_colors[i] = PALETTE_COLOR_UNUSED;
  68.  
  69.     return 0;
  70. }
  71.  
  72.  
  73.  
  74. /***************************************************************************
  75.  
  76.   Memory handlers
  77.  
  78. ***************************************************************************/
  79.  
  80. WRITE_HANDLER( sf1_videoram_w )
  81. {
  82.     int old = READ_WORD(&videoram[offset]);
  83.     int new = COMBINE_WORD(old, data);
  84.     if (old != new)
  85.     {
  86.         WRITE_WORD(&videoram[offset], new);
  87.         tilemap_mark_tile_dirty(char_tilemap,offset/2);
  88.     }
  89. }
  90.  
  91. WRITE_HANDLER( sf1_deltaxb_w )
  92. {
  93.     tilemap_set_scrollx(bgb_tilemap, 0, data);
  94. }
  95.  
  96. WRITE_HANDLER( sf1_deltaxm_w )
  97. {
  98.     tilemap_set_scrollx(bgm_tilemap, 0, data);
  99. }
  100.  
  101. void sf1_active_w(int data)
  102. {
  103.     sf1_active = data;
  104.     tilemap_set_enable(bgb_tilemap, data & 0x20);
  105.     tilemap_set_enable(bgm_tilemap, data & 0x40);
  106.     tilemap_set_enable(char_tilemap, data & 0x08);
  107. }
  108.  
  109.  
  110.  
  111. /***************************************************************************
  112.  
  113.   Display refresh
  114.  
  115. ***************************************************************************/
  116.  
  117. INLINE int sf1_invert(int nb)
  118. {
  119.     static int delta[4] = {0x00, 0x18, 0x18, 0x00};
  120.     return nb^delta[(nb>>3)&3];
  121. }
  122.  
  123.  
  124. static void mark_sprites_palette(void)
  125. {
  126.     unsigned char *umap = &palette_used_colors[Machine->drv->gfxdecodeinfo[2].color_codes_start];
  127.     unsigned int cmap = 0;
  128.     unsigned char *pt = sf1_objectram + 0x2000-0x40;
  129.     int i, j;
  130.  
  131.     while(pt>=sf1_objectram)
  132.     {
  133.         int at = READ_WORD(pt+2);
  134.         int y = READ_WORD(pt+4);
  135.         int x = READ_WORD(pt+6);
  136.  
  137.         if(x>32 && x<415 && y>0 && y<256)
  138.             cmap |= (1<<(at & 0x0f));
  139.  
  140.         pt -= 0x40;
  141.     }
  142.  
  143.     for(i=0;i<16;i++)
  144.     {
  145.         if(cmap & (1<<i))
  146.         {
  147.             for(j=0;j<15;j++)
  148.                 *umap++ = PALETTE_COLOR_USED;
  149.             *umap++ = PALETTE_COLOR_TRANSPARENT;
  150.         }
  151.         else
  152.         {
  153.             for(j=0;j<16;j++)
  154.                 *umap++ = PALETTE_COLOR_UNUSED;
  155.         }
  156.     }
  157. }
  158.  
  159. static void draw_sprites(struct osd_bitmap *bitmap)
  160. {
  161.     unsigned char *pt = sf1_objectram + 0x2000-0x40;
  162.  
  163.     while(pt>=sf1_objectram) {
  164.         int c = READ_WORD(pt);
  165.         int at = READ_WORD(pt+2);
  166.         int y = READ_WORD(pt+4);
  167.         int x = READ_WORD(pt+6);
  168.  
  169.         if(x>32 && x<415 && y>0 && y<256) {
  170.             if(!(at&0x400)) {
  171.                 drawgfx(bitmap,
  172.                         Machine->gfx[2],
  173.                         sf1_invert(c),
  174.                         at & 0xf,
  175.                         at & 0x100, at & 0x200,
  176.                         x, y,
  177.                         &Machine->drv->visible_area, TRANSPARENCY_PEN, 15);
  178.             } else {
  179.                 int c1, c2, c3, c4;
  180.                 switch(at & 0x300) {
  181.                 case 0x000:
  182.                 default:
  183.                     c1 = c;
  184.                     c2 = c+1;
  185.                     c3 = c+16;
  186.                     c4 = c+17;
  187.                     break;
  188.                 case 0x100:
  189.                     c1 = c+1;
  190.                     c2 = c;
  191.                     c3 = c+17;
  192.                     c4 = c+16;
  193.                     break;
  194.                 case 0x200:
  195.                     c1 = c+16;
  196.                     c2 = c+17;
  197.                     c3 = c;
  198.                     c4 = c+1;
  199.                     break;
  200.                 case 0x300:
  201.                     c1 = c+17;
  202.                     c2 = c+16;
  203.                     c3 = c+1;
  204.                     c4 = c;
  205.                     break;
  206.                 }
  207.                 drawgfx(bitmap,
  208.                         Machine->gfx[2],
  209.                         sf1_invert(c1),
  210.                         at & 0xf,
  211.                         at & 0x100, at & 0x200,
  212.                         x, y,
  213.                         &Machine->drv->visible_area, TRANSPARENCY_PEN, 15);
  214.                 drawgfx(bitmap,
  215.                         Machine->gfx[2],
  216.                         sf1_invert(c2),
  217.                         at & 0xf,
  218.                         at & 0x100, at & 0x200,
  219.                         x+16, y,
  220.                         &Machine->drv->visible_area, TRANSPARENCY_PEN, 15);
  221.                 drawgfx(bitmap,
  222.                         Machine->gfx[2],
  223.                         sf1_invert(c3),
  224.                         at & 0xf,
  225.                         at & 0x100, at & 0x200,
  226.                         x, y+16,
  227.                         &Machine->drv->visible_area, TRANSPARENCY_PEN, 15);
  228.                 drawgfx(bitmap,
  229.                         Machine->gfx[2],
  230.                         sf1_invert(c4),
  231.                         at & 0xf,
  232.                         at & 0x100, at & 0x200,
  233.                         x+16, y+16,
  234.                         &Machine->drv->visible_area, TRANSPARENCY_PEN, 15);
  235.             }
  236.         }
  237.         pt -= 0x40;
  238.     }
  239. }
  240.  
  241.  
  242. void sf1_vh_screenrefresh(struct osd_bitmap *bitmap, int full_refresh)
  243. {
  244.     tilemap_update(ALL_TILEMAPS);
  245.  
  246.     palette_init_used_colors();
  247.  
  248.     if(sf1_active & 0x80)
  249.         mark_sprites_palette();
  250.  
  251.     if (palette_recalc())
  252.         tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);
  253.  
  254.     tilemap_render(ALL_TILEMAPS);
  255.  
  256.     tilemap_draw(bitmap, bgb_tilemap, 0);
  257.  
  258.     if(!(sf1_active & 0x20))
  259.         fillbitmap(bitmap,palette_transparent_pen,&Machine->drv->visible_area);
  260.  
  261.     tilemap_draw(bitmap, bgm_tilemap, 0);
  262.  
  263.     if(sf1_active & 0x80)
  264.         draw_sprites(bitmap);
  265.  
  266.     tilemap_draw(bitmap, char_tilemap, 0);
  267. }
  268.